#define _CRT_SECURE_NO_WARNINGS

#include "Stack.h"
#include "Queue.h"

//
void BaseSwitch(int num, int n)
{
	ST stack;
	StackInit(&stack);
	while (num)
	{
		int ret = num % n;
		if (ret < 10)
		{
			StackPushBack(&stack, ret+48);
		}
		else
		{
			StackPushBack(&stack, ret + 55);
		}
		num /= n;
	}

	while (!StackEmpty(&stack))
	{
		printf("%c", StackTop(&stack));
		StackPopBack(&stack);
	}
	StackDesTory(&stack);
}
int main()
{
	int num = 0;
	int n = 0;
	scanf("%d %d", &num, &n);

	BaseSwitch(num,n);

	return 0;
}

void BaseSwitch_little(float num, int n)
{
	Q q;
	QueueInit(&q);

	while (num)
	{
		int ret = (int)(n*num);

		if (ret < 10)
		{
			QueuePushBack(&q, ret+48);
		}
		else
		{
			QueuePushBack(&q, ret + 55);
		}
		num = (num * n) - (int)(n * num);

	}
	while (!QueueEmpty(&q))
	{
		printf("%c", QueueFront(&q));
		QueuePop(&q);
	}

	QueueDesTory(&q);
}
int main()
{
	float num = 0;
	int n = 0;
	scanf("%f %d", &num, &n);

	BaseSwitch_little(num,n);
	return 0;
}
// struct ListNode {
//    int val;
//    struct ListNode* next;
//};
//
// typedef struct ListNode Node;
// bool isPalindrome(struct ListNode* head) {
//     if (head == NULL)
//         return true;
//     if (head->next == NULL)
//         return true;
// 
//     Node* ptail;
//     Node* phead = NULL;
//     Node* cur = head;
//     while (cur)
//     {
//         ptail = (Node*)malloc(sizeof(Node));
//         ptail->val = cur->val;
//         ptail->next = NULL;
//
//         if (phead == NULL)
//         {
//             phead = ptail;
//         }
//         else
//         {
//             ptail->next = phead;
//             phead = ptail;
//         }
//         cur = cur->next;
//     }
//     cur = head;
//     while (phead)
//     {
//         if (phead->val != cur->val)
//             return false;
//         cur = cur->next;
//         phead = phead->next;
//     }
//     return true;
// }
//
//
//int main()
//{
//    Node* n1 = (Node*)malloc(sizeof(Node));
//    n1->val = 1;
//    n1->next = NULL;
//
//    Node* n2 = (Node*)malloc(sizeof(Node));
//    n2->val = 2;
//    n2->next = NULL;
//
//    Node* n3 = (Node*)malloc(sizeof(Node));
//    n3->val = 1;
//    n3->next = NULL;
//
//
//    Node* n4 = (Node*)malloc(sizeof(Node));
//    n4->val = 1;
//    n4->next = NULL;
//
//    Node* n5 = (Node*)malloc(sizeof(Node));
//    n5->val = 5;
//    n5->next = NULL;
//
//    Node* n6 = (Node*)malloc(sizeof(Node));
//    n6->val = 2;
//    n6->next = NULL;
//
//    n1->next = n2;
//    n2->next = n3;
//    n3->next = n4;
//    //n4->next = n5;
//    //n5->next = n6;
//
//
//    bool ret = isPalindrome(n1);
//    if (ret)
//        printf("1");
//    else
//        printf("0");
//    return 0;
//}